Vrs rate feedback

ABSTRACT

Techniques for performing shader operations are provided. The techniques include, performing pixel shading at a shading rate defined by pixel shader variable rate shading (“VRS”) data, and updating the pixel VRS data that indicates one or more shading rates for one or more tiles based on whether the tiles of the one or more tiles include triangle edges or do not include triangle edges, to generate updated VRS data.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application claims the benefit of U.S. Non-Provisional applicationNo. 16/723,969, entitled “VRS RATE FEEDBACK,” filed on Dec. 20, 2019,the entirety of which are hereby incorporated herein by reference.

BACKGROUND

Three-dimensional (“3D”) graphics processing pipelines perform a seriesof steps to convert input geometry into a two-dimensional (“2D”) imagefor display on a screen. Some of the steps include rasterization andpixel shading. Rasterization involves identifying which pixels (orsub-pixel samples) are covered by triangles provided by stages of thepipeline prior to the rasterizer. The output of rasterization includesquads—a block of 2×2 pixels—and coverage data that indicates whichsamples are covered by the pixels of the quads. The pixel shader shadesthe pixels of the quads, and the pixels of the quads are then written toa frame buffer. Because pixel shading is very resource-intensive,techniques are constantly being developed to improve efficiency of pixelshading.

BRIEF DESCRIPTION OF THE DRAWINGS

A more detailed understanding can be had from the following description,given by way of example in conjunction with the accompanying drawingswherein:

FIG. 1 is a block diagram of an example device in which one or morefeatures of the disclosure can be implemented;

FIG. 2 illustrates details of the device of FIG. 1, according to anexample;

FIG. 3 is a block diagram showing additional details of the graphicsprocessing pipeline illustrated in FIG. 2;

FIG. 4 illustrates operations for a variable rate shading technique,according to an example;

FIG. 5 illustrates operations of the graphics processing pipelinerelated to generating a VRS rate feedback buffer, according to anexample;

FIG. 6 illustrates an example series of operations for generating theVRS rate feedback buffer; and

FIG. 7 is a flow diagram of a method for generating data for a VRS ratefeedback buffer, according to an example.

DETAILED DESCRIPTION

Techniques for performing shader operations are provided. The techniquesinclude, performing pixel shading at a shading rate defined by pixelshader variable rate shading (“VRS”) data, and updating the pixel VRSdata that indicates one or more shading rates for one or more tilesbased on whether the tiles of the one or more tiles include triangleedges or do not include triangle edges, to generate updated VRS data.

FIG. 1 is a block diagram of an example device 100 in which one or morefeatures of the disclosure can be implemented. The device 100 could beone of, but is not limited to, for example, a computer, a gaming device,a handheld device, a set-top box, a television, a mobile phone, a tabletcomputer, or other computing device. The device 100 includes a processor102, a memory 104, a storage 106, one or more input devices 108, and oneor more output devices 110. The device 100 also includes one or moreinput drivers 112 and one or more output drivers 114. Any of the inputdrivers 112 are embodied as hardware, a combination of hardware andsoftware, or software, and serve the purpose of controlling inputdevices 112 (e.g., controlling operation, receiving inputs from, andproviding data to input drivers 112). Similarly, any of the outputdrivers 114 are embodied as hardware, a combination of hardware andsoftware, or software, and serve the purpose of controlling outputdevices 114 (e.g., controlling operation, receiving inputs from, andproviding data to output drivers 114). It is understood that the device100 can include additional components not shown in FIG. 1.

In various alternatives, the processor 102 includes a central processingunit (CPU), a graphics processing unit (GPU), a CPU and GPU located onthe same die, or one or more processor cores, wherein each processorcore can be a CPU or a GPU. In various alternatives, the memory 104 islocated on the same die as the processor 102, or is located separatelyfrom the processor 102. The memory 104 includes a volatile ornon-volatile memory, for example, random access memory (RAM), dynamicRAM, or a cache.

The storage 106 includes a fixed or removable storage, for example,without limitation, a hard disk drive, a solid state drive, an opticaldisk, or a flash drive. The input devices 108 include, withoutlimitation, a keyboard, a keypad, a touch screen, a touch pad, adetector, a microphone, an accelerometer, a gyroscope, a biometricscanner, or a network connection (e.g., a wireless local area networkcard for transmission and/or reception of wireless IEEE 802 signals).The output devices 110 include, without limitation, a display, aspeaker, a printer, a haptic feedback device, one or more lights, anantenna, or a network connection (e.g., a wireless local area networkcard for transmission and/or reception of wireless IEEE 802 signals).

The input driver 112 and output driver 114 include one or more hardware,software, and/or firmware components that are configured to interfacewith and drive input devices 108 and output devices 110, respectively.The input driver 112 communicates with the processor 102 and the inputdevices 108, and permits the processor 102 to receive input from theinput devices 108. The output driver 114 communicates with the processor102 and the output devices 110, and permits the processor 102 to sendoutput to the output devices 110. The output driver 114 includes anaccelerated processing device (“APD”) 116 which is coupled to a displaydevice 118, which, in some examples, is a physical display device or asimulated device that uses a remote display protocol to show output. TheAPD 116 is configured to accept compute commands and graphics renderingcommands from processor 102, to process those compute and graphicsrendering commands, and to provide pixel output to display device 118for display. As described in further detail below, the APD 116 includesone or more parallel processing units configured to perform computationsin accordance with a single-instruction-multiple-data (“SIMD”) paradigm.Thus, although various functionality is described herein as beingperformed by or in conjunction with the APD 116, in variousalternatives, the functionality described as being performed by the APD116 is additionally or alternatively performed by other computingdevices having similar capabilities that are not driven by a hostprocessor (e.g., processor 102) and configured to provide graphicaloutput to a display device 118. For example, it is contemplated that anyprocessing system that performs processing tasks in accordance with aSIMD paradigm may be configured to perform the functionality describedherein. Alternatively, it is contemplated that computing systems that donot perform processing tasks in accordance with a SIMD paradigm performsthe functionality described herein.

FIG. 2 illustrates details of the device 100 and the APD 116, accordingto an example. The processor 102 (FIG. 1) executes an operating system120, a driver 122, and applications 126, and may also execute othersoftware alternatively or additionally. The operating system 120controls various aspects of the device 100, such as managing hardwareresources, processing service requests, scheduling and controllingprocess execution, and performing other operations. The APD driver 122controls operation of the APD 116, sending tasks such as graphicsrendering tasks or other work to the APD 116 for processing. The APDdriver 122 also includes a just-in-time compiler that compiles programsfor execution by processing components (such as the SIMD units 138discussed in further detail below) of the APD 116.

The APD 116 executes commands and programs for selected functions, suchas graphics operations and non-graphics operations that may be suitedfor parallel processing. The APD 116 can be used for executing graphicspipeline operations such as pixel operations, geometric computations,and rendering an image to display device 118 based on commands receivedfrom the processor 102. The APD 116 also executes compute processingoperations that are not directly related to graphics operations, such asoperations related to video, physics simulations, computational fluiddynamics, or other tasks, based on commands received from the processor102. In some examples, these compute processing operations are performedby executing compute shaders on the SIMD units 138.

The APD 116 includes compute units 132 that include one or more SIMDunits 138 that are configured to perform operations at the request ofthe processor 102 (or another unit) in a parallel manner according to aSIMD paradigm. The SIMD paradigm is one in which multiple processingelements share a single program control flow unit and program counterand thus execute the same program but are able to execute that programwith different data. In one example, each SIMD unit 138 includes sixteenlanes, where each lane executes the same instruction at the same time asthe other lanes in the SIMD unit 138 but can execute that instructionwith different data. Lanes can be switched off with predication if notall lanes need to execute a given instruction. Predication can also beused to execute programs with divergent control flow. More specifically,for programs with conditional branches or other instructions wherecontrol flow is based on calculations performed by an individual lane,predication of lanes corresponding to control flow paths not currentlybeing executed, and serial execution of different control flow pathsallows for arbitrary control flow.

The basic unit of execution in compute units 132 is a work-item. Eachwork-item represents a single instantiation of a program that is to beexecuted in parallel in a particular lane. Work-items can be executedsimultaneously (or partially simultaneously and partially sequentially)as a “wavefront” on a single SIMD processing unit 138. One or morewavefronts are included in a “work group,” which includes a collectionof work-items designated to execute the same program. A work group canbe executed by executing each of the wavefronts that make up the workgroup. In alternatives, the wavefronts are executed on a single SIMDunit 138 or on different SIMD units 138. Wavefronts can be thought of asthe largest collection of work-items that can be executed simultaneously(or pseudo-simultaneously) on a single SIMD unit 138.“Pseudo-simultaneous” execution occurs in the case of a wavefront thatis larger than the number of lanes in a SIMD unit 138. In such asituation, wavefronts are executed over multiple cycles, with differentcollections of the work-items being executed in different cycles. An APDscheduler 136 is configured to perform operations related to schedulingvarious workgroups and wavefronts on compute units 132 and SIMD units138.

The parallelism afforded by the compute units 132 is suitable forgraphics related operations such as pixel value calculations, vertextransformations, and other graphics operations. Thus in some instances,a graphics pipeline 134, which accepts graphics processing commands fromthe processor 102, provides computation tasks to the compute units 132for execution in parallel.

The compute units 132 are also used to perform computation tasks notrelated to graphics or not performed as part of the “normal” operationof a graphics pipeline 134 (e.g., custom operations performed tosupplement processing performed for operation of the graphics pipeline134). An application 126 or other software executing on the processor102 transmits programs that define such computation tasks to the APD 116for execution.

FIG. 3 is a block diagram showing additional details of the graphicsprocessing pipeline 134 illustrated in FIG. 2. The graphics processingpipeline 134 includes stages that each performs specific functionalityof the graphics processing pipeline 134. Each stage is implementedpartially or fully as shader programs executing in the programmablecompute units 132, or partially or fully as fixed-function,non-programmable hardware external to the compute units 132.

The input assembler stage 302 reads primitive data from user-filledbuffers (e.g., buffers filled at the request of software executed by theprocessor 102, such as an application 126) and assembles the data intoprimitives for use by the remainder of the pipeline. The input assemblerstage 302 can generate different types of primitives based on theprimitive data included in the user-filled buffers. The input assemblerstage 302 formats the assembled primitives for use by the rest of thepipeline.

The vertex shader stage 304 processes vertices of the primitivesassembled by the input assembler stage 302. The vertex shader stage 304performs various per-vertex operations such as transformations,skinning, morphing, and per-vertex lighting. Transformation operationsinclude various operations to transform the coordinates of the vertices.These operations include one or more of modeling transformations,viewing transformations, projection transformations, perspectivedivision, and viewport transformations, which modify vertex coordinates,and other operations that modify non-coordinate attributes.

The vertex shader stage 304 is implemented partially or fully as vertexshader programs to be executed on one or more compute units 132. Thevertex shader programs are provided by the processor 102 and are basedon programs that are pre-written by a computer programmer. The driver122 compiles such computer programs to generate the vertex shaderprograms having a format suitable for execution within the compute units132.

The hull shader stage 306, tessellator stage 308, and domain shaderstage 310 work together to implement tessellation, which converts simpleprimitives into more complex primitives by subdividing the primitives.The hull shader stage 306 generates a patch for the tessellation basedon an input primitive. The tessellator stage 308 generates a set ofsamples for the patch. The domain shader stage 310 calculates vertexpositions for the vertices corresponding to the samples for the patch.The hull shader stage 306 and domain shader stage 310 can be implementedas shader programs to be executed on the compute units 132 that arecompiled by the driver 122 as with the vertex shader stage 304.

The geometry shader stage 312 performs vertex operations on aprimitive-by-primitive basis. A variety of different types of operationscan be performed by the geometry shader stage 312, including operationssuch as point sprite expansion, dynamic particle system operations,fur-fin generation, shadow volume generation, single passrender-to-cubemap, per-primitive material swapping, and per-primitivematerial setup. In some instances, a geometry shader program that iscompiled by the driver 122 and that executes on the compute units 132performs operations for the geometry shader stage 312.

The rasterizer stage 314 accepts and rasterizes simple primitives(triangles) generated upstream from the rasterizer stage 314.Rasterization consists of determining which screen pixels (or sub-pixelsamples) are covered by a particular primitive. Rasterization isperformed by fixed function hardware.

The pixel shader stage 316 calculates output values for screen pixelsbased on the primitives generated upstream and the results ofrasterization. The pixel shader stage 316 may apply textures fromtexture memory. Operations for the pixel shader stage 316 are performedby a pixel shader program that is compiled by the driver 122 and thatexecutes on the compute units 132.

The output merger stage 318 accepts output from the pixel shader stage316 and merges those outputs into a frame buffer, performing operationssuch as z-testing and alpha blending to determine the final color forthe screen pixels.

In one mode of operation, the rasterization performed by the rasterizerstage 314 is done at the same resolution as pixel shading performed bythe pixel shader stage 316. By way of more detailed background than thedescription provided above, the rasterizer stage 314 accepts trianglesfrom earlier stages and performs scan conversion on the triangles togenerate fragments. The fragments are data for individual pixels of arender target and include information such as location, depth, andcoverage data, and later, after the pixel shader stage, shading datasuch as colors. The render target is the destination image to whichrendering is occurring (i.e., colors or other values are being written).

Typically, the fragments are grouped into quads, each quad includingfragments corresponding to four neighboring pixel locations (that is,2×2 fragments). Scan conversion of a triangle involves generating afragment for each pixel location covered by the triangle. If the rendertarget is a multi-sample image, then each pixel has multiple samplelocations, each of which is tested for coverage. The fragment recordscoverage data for the samples within the pixel area that are covered bythe triangle. The fragments that are generated by the rasterizer stage314 are transmitted to the pixel shader stage 316, which determinescolor values for those fragments, and may determine other values aswell.

Performing rasterization and pixel shading at the same resolution meansthat for each fragment generated by the rasterizer, the pixel shader 316performs a calculation to determine a color for that fragment. In otherwords, the area of screen-space occupied by a pixel is the same area asthe precision with which colors are determined. In one example, in theSIMD-based hardware of the compute units 132, each fragment generated bythe rasterizer stage 314 is shaded by a different work-item. Thus, thereis a one-to-one correspondence between generated fragments andwork-items spawned to shade those fragments. Note that the rasterizerstage 314 typically performs depth testing, culling fragments occludedby previously-rendered fragments. Thus, there is a one-to-onecorrespondence between fragments that survive this depth culling andwork-items spawned to color those surviving fragments. Another way tounderstand the mode of operation in which rasterization is performed atthe same resolution as shading is that the resolution at which the edgesof a triangle can be defined is equivalent to the resolution at whichcolors of that triangle can be defined.

One issue with the above mode of operation, in which rasterizationoccurs at the same resolution as pixel shading occurs for triangles thathave a fixed color or low frequency change in color. For such triangles,pixel shading operations on nearby fragments produce the same or similarcolor and are effectively redundant. A similar result could therefore beperformed with a much smaller number of pixel shader operations. Thus,it is advantageous to decouple the rasterization resolution from theshading resolution, and a technique for allowing rasterization to occurat a different resolution than pixel shading is provided below. Theadvantage of such a technique is a reduction in the number of pixelshader operations being performed, which reduces processing load andimproves performance.

FIG. 4 illustrates a variable rate shading (“VRS”) technique accordingto an example. At state 420, the rasterizer stage 314 receives atriangle 402 having vertices that define positions with respect toscreen pixels 404. At state 422, the rasterizer stage 314 identifiesfragments 406 covered by the triangle 402. A fragment 406 is a data itemcorresponding to a screen pixel 404 that indicates that at least onesample position within that screen pixel 404 is covered by a triangle402. In state 422, each of the fragments 406 illustrated has at leastone sample position covered by triangle 402. A “screen pixel” is an areaof a render target (portion of memory to which pipeline output iswritten) for which rendering output is written. A render target includesmultiple pixels, each of which includes data such as color data andpotentially other data. Although the term “screen pixel” is used, itshould be understood that this term sometimes means a pixel of anyrender target, and not necessarily a render target that is output fordisplay on a screen.

At state 424, the rasterizer stage 314 down-samples the coveredfragments 406 illustrated at state 422. Down-sampling involves creatingcoarse fragments 408 that each correspond to at least one covered finefragment 406 (where fragments 406 are called fine fragments as thefragments 406 cover a smaller screen area than the coarse fragments).The coarse fragments are created so that when shading occurs by thepixel shader stage 316, the amount of shading that needs to occur isreduced. Thus at state 426, the pixel shader stage 316 shades the coarsefragments to generate shaded coarse fragments 410. At state 428, theoutput merger stage 318 up-samples the shaded coarse fragments 410 togenerate up-sampled (or “fine”) fragments 412. Up-sampling involvesgenerating multiple up-sampled fragments 412 from one or more coarsefragments 410, where each up-sampled fragment 412 has the same color asthe color generated for the corresponding coarse fragment 410 and fallswithin the render target area defined for the coarse fragment. Theoutput merger stage 318 then writes the up-sampled fragments 412 to therender target surface.

It should be noted that although the variable rate shading technique ofFIG. 4 reduces the amount of work performed by the pixel shader 316,other steps are beneficially used to improve the performance of othergraphics processing operations. More specifically, the variable rateshading technique obtains data indicating shading rates for differentshading rate tiles of a render target. A shading rate tile is a portionof a render target including multiple pixels. The shading rates aredefined at the granularity of the shading rate tiles. The shading ratefor a particular tile indicates the rate at which shading is performedfor the fragments within that tile. For example, a 4:1 shading ratemeans that a single pixel shader work-item is used to shade fragmentsfor four different pixels. The data indicating the shading rates(“shading rate data”) for the different shading rate tiles is obtainedin any technically feasible manner, such as from within data specifiedby an application, within data determined automatically by a portion ofthe graphics processing pipeline 300 based on characteristics of thescene being rendered, or based on any other technically feasibletechnique. In some examples, shading rate data is specified in a shadingrate map that indicates which portions of the render target are toreceive which shading rate. In some examples, shading rate data isspecified on a per-triangle basis, where each triangle has an associatedshading rate. In some examples, the shading rate data is specified on aper-triangle and per-tile basis, in which tiles within triangles arepermitted to have different shading rates.

As described above, this shading rate data is used to reduce the amountof work performed at the pixel shader stage 316. This shading rate datais also beneficially used for other purposes such as to reduce theamount of work performed by post-processing tasks. A post-processingtask is a task performed on data within a render target such as theframe buffer and serves to modify that data or generate additional datato achieve a visual effect or other effect. Some example post processingtasks include generating direct shadows via a ray tracing orrasterization technique, generating direct lighting using a computetechnique, generating reflections, generating global illumination usinga ray tracing technique, ambient occlusion using ray tracing or acompute technique, generating transparency and translucency effectsusing a ray tracing technique, and performing other post processingoperations such as camera lens related effects like simulating shallowdepth of field.

It is possible for any such technique to use shading rate data to reducethe amount of processing performed by that technique. However, suchtechniques cannot use the same data as the data provided as input to thegraphics processing pipeline 300 for the purpose of reducing the amountof work performed by the techniques. Specifically, at the edges oftriangles, such techniques generally should be performed at a rate thatis not reduced according to the shading rate data, otherwise it ispossible for the edges of triangles to have obvious artifacts. However,the shading rate data for a tile when used for pixel shading is agnosticas to whether the tile includes a triangle edge. Therefore, the graphicsprocessing pipeline 300 modifies the shading rate data that is used toreduce the shading rate at the pixel shader into post-processing shadingrate data. Specifically, the graphics processing pipeline 300 maintainsthe shading rate used for the pixel shader except where a triangle thatis visible in the final rendered image embodied in the render target hasan edge through a tile. In the situation where such a triangle exists ina tile, the graphics processing pipeline 300 sets the shading rate forthe tile for post-processing techniques to indicate that such a triangleedge exists in that tile. In various examples, the post-processingtechniques treat such a tile as a tile that is to be processed at theresolution of the render target (i.e., a resolution that is not reducedper the shading rate data). Note the term “final rendered image” abovemeans the image in the render target after no more updates from thegraphics processing pipeline 300 are applied to the render target. Wherethe render target is the frame buffer, the “final rendered image” is theimage that is displayed on the screen.

FIG. 5 illustrates operations of the graphics processing pipeline 300related to generating a VRS rate feedback buffer, according to anexample. The VRS rate feedback buffer includes data that indicates theshading rate to be used for each tile for post-processing tasks. FIG. 5illustrates a portion of the pipeline stages of FIG. 3 and also includessome pipeline stages not illustrated in FIG. 3. Specifically, therasterizer stage 314 is shown, which feeds into a coarse depth testblock 315(1), a fine depth test block 315(2), the pixel shader stage316, and the output merger stage 318.

The rasterizer stage 314 accepts shading rate data and triangles fromearlier in the graphics processing pipeline 300. The rasterizer 314rasterizes the triangles to generate fragments based on the shadingrate. As described elsewhere herein, the shading rate data indicates,for each tile, the rate at which the pixel shader 316 is to shade thattile. A tile is a portion of the area represented in a render target.The rasterizer 314 generates fragments based on this shading rate dataand passes the shading rate data and the fragments to the coarse depthtest block 315(1) and the output merger stage 318. The coarse depth testblock 315(1) performs a coarse depth test. The coarse depth testinvolves determining whether all fragments of a tile are occluded by allfragments in tiles previously encountered by the coarse depth test unit315(1). The coarse depth test is conservative, meaning that the coarsedepth test block 315(1) rejects all fragments of a tile if all fragmentsin the tile are occluded by all fragments of a previously seen tile butdoes not reject any of the fragments of the tile if at least onefragment in the tile is not occluded by a any fragment of a previouslyseen tile. In some implementations, the tiles for which this coarsedepth test is performed are the same size as the tiles for which theshading rates are specified by the shading rate data.

The fine depth test 315(2) performs a depth test for individualfragments of the tiles that survive the coarse depth test 315(1). Morespecifically, the fine depth test 315(2) receives the fragments of tilesthat survive the coarse depth test and compares the depths of thosefragments to the depths of fragments previously seen by the fine depthtest block 315(2). The fine depth test 315(2) rejects fragments on aper-fragment basis, rather than on a per-tile basis. In some examples ormodes of operation, if a fragment is considered to be occluded by apreviously seen fragment, then that fragment is discarded and if afragment is considered to be not occluded by a previously seen fragment,then that fragment is sent to the pixel shader stage 316 for pixelshading. In other examples or modes of operation, the fine depth test315(2) performs one of a selectable test that does not necessarilyindicate whether a fragment is occluded to determine whether to discardor keep a fragment. Note that at this stage, the fragments have the sizeas determined by the shading rate data, since those are the fragmentsthat are output by the rasterizer stage 314. In other words, thefragments to be shaded at the pixel shader stage 316 have a size on therender target that corresponds to the shading rate—coarser fragmentstake up a larger area on the render target than finer fragments.

The pixel shader stage 316 shades the fragments that survive the finedepth test 315(2) and outputs the shaded fragments to the output mergerstage 318. The output merger stage 318 performs final operations such asa final depth test (in case depth is modified by the pixel shader stage316), and writes the shaded fragments to a render target.

The output merger stage 318 generates the VRS rate feedback buffer 320based on shading rate data received from the coarse depth test 315(1) aswell as based on coverage modification, if any, that occurs at the pixelshader stage 316. The VRS rate feedback buffer 320 is the data structurethat stores information about what shading rate to use forpost-processing tasks. Thus when post-processing tasks occur, thepost-processing tasks read the VRS rate feedback buffer 320 and performoperations based on the shading rate in the VRS rate feedback buffer320.

The output merger stage 318 generates the VRS rate feedback buffer 320in the following manner. The output merger stage 318 receives shadingrate data from the coarse depth test block 315(1), as modified by thatblock in consideration of whether a tile includes a triangle edge. Morespecifically, the coarse depth test block 315(1) receives fragmentsgenerated by the rasterizer stage 314 and receives the shading ratedata. The coarse depth test block 315(1) performs the coarse depth test315(1) for fragments within a tile. If all fragments within a tile areconsidered to pass the coarse depth test, then the coarse depth testblock 315(1) passes shading rate data for that tile to the output mergerstage 318, where the shading rate data indicates the shading ratespecified by the shading rate data input to the rasterizer stage 314. Inother words, in the scenario where a tile is fully uncovered bypreviously seen tiles, the shading rate data passed from the coarsedepth test block 315(1) to the output merger stage 318 for that tile isthe shading rate specified for pixel shading to the rasterizer stage314.

If no fragments within a tile are considered to pass the coarse depthtest, then the entire tile of fragments is culled and the coarse depthtest 315(1) does not pass any shading rate data for that tile to theoutput merger stage 318. If some fragments within a tile are consideredto pass the coarse depth test and some fragments within the tile areconsidered to not pass the coarse depth test, then the coarse depth test315(1) provides an indication for that tile to the output merger stage318 indicating that that tile includes a triangle edge. As describedelsewhere herein, in some implementations, a post-processing task thatreceives this indication performs post-processing operations at theresolution of the render target instead of the reduced resolutionperformed by the pixel shader stage 316. A post-processing task thatreceives an indication of the pixel shading VRS data performspost-processing operations at that resolution, which, in some examplesis different than the resolution of the render target (for example,coarser).

The output merger stage 318 receives the per-tile shading rate data fromthe coarse depth test 315(1) and determines whether to modify thatper-tile shading rate data based on output from the pixel shader stage316. More specifically, it is possible for the pixel shader stage 316 tomodify aspects of fragments being shaded such that a fragment that isconsidered visible by the coarse depth test block 315(1) is no longervisible after modification by the pixel shader stage 316.

In an example, the pixel shader stage 316 processes fragments of a tilethat is marked as fully not occluded by the coarse depth test block315(1). The pixel shader stage 316 marks a particular fragment of thattile as not covered (the term “covered” means “covered by a triangle andthus able to be rendered—a non-covered fragment is not visible and thusis not rendered to the render target). If other fragments of that tileremain covered, then the tile is not fully covered and the output mergerstage 318 modifies the shading rate data received from the coarse depthtest block 315(1) to include an indication that the tile includes atriangle edge and thus is to be processed in post-processing at theresolution of the render target rather than at the reduced resolutionthat the pixel shader stage 316 operates at. More specifically, becausethe tile is determined to be fully non-occluded by the coarse depth testblock 315(1), but after the pixel shader stage 216, the tile is notfully visible (due to coverage being modified), the fragments of thetile cannot be post-processed at the reduced shading rate and thereforethe output merger stage 318 sets the shading rate for that tile toindicate that the tile includes a triangle edge.

In another example, the pixel shader stage 316 processes fragments of atile that is marked as fully not occluded by the coarse depth test block315(1). The pixel shader stage 316 modifies the depth of some of thefragments of that tile such that those fragments are occluded by otherfragments. In that situation, if at least some of the fragments arestill visible, then the tile is not fully covered and the output mergerstage 318 modifies the shading rate data received from the coarse depthtest block 315(1) to include an indication that the tile includes atriangle edge.

The output merger stage 318 performs a depth comparison for the per-tileshading rate data, as modified per operations at the pixel shader stage316, before writing such data to the VRS rate feedback buffer 320. Morespecifically, it is possible for the graphics processing pipeline 300 toprocess multiple sets of fragments for the same portion of the rendertarget corresponding to a tile. In an example, the graphics processingpipeline 300 renders one triangle at a far depth, another triangle at anintermediate depth, and a third triangle at a close depth, where allsuch triangles cover the same render target area that corresponds to thesame tile. In such instances, the VRS rate feedback buffer 320 includesdata for the fragments that are actually present in the render targetbuffer. For example, if the third triangle fully occludes the firsttriangle and the second triangle within a particular tile, then the VRSrate feedback buffer should include the VRS rate for the third triangleat that tile. Note that if multiple triangles are visible in a tile,then the VRS rate feedback buffer 320 indicates that the tile includes atriangle edge.

In one example, the output merger stage 318 writes data for tiles thatare visible in the VRS rate feedback buffer 320 in the following manner.The output merger stage 318 generates a coverage mask for fragments tobe written to the frame buffer. The output merger stage 318 examinesthis coverage mask for each tile. For any particular tile, if allsamples are considered covered, then the output merger stage 318 writesthe value that the tile was rendered at to the VRS rate feedback buffer320 for that tile. If some but not all samples are covered, then theoutput merger stage 318 writes the triangle edge value to the VRS ratefeedback buffer 320 for that tile. If no samples are covered, then theoutput merger stage 318 does not write anything to the VRS rate feedbackbuffer 320 for that tile.

In another example, the output merger stage 318 achieves writing datafor tiles that are visible in the VRS rate feedback buffer 320, in thefollowing manner. The output merger stage 318 receives the shading ratedata from the coarse depth test 315(1) and modifies the shading ratedata per output from the pixel shading stage 316 as described elsewhereherein. The result is an item of shading rate data for the tile. Thisitem of shading rate data has an associated depth, which is the depth ofthe fragment of the tile that is farthest from the camera (because thecoarse depth test is conservative, the coarse depth test checks whetherthe farthest fragment of a tile is occluded by the closest depth for anytile already encountered by the coarse depth test). The output mergerstage 318 writes this item of shading rate data to the VRS rate feedbackbuffer 320 if the depth of that tile is closer than the farthest depthof the VRS data item in the VRS rate feedback buffer 320 at the sametile location. In an example, the output merger stage 318 encounters VRSrate data for a tile having a depth of 10 (where higher depths arefarther from the camera) and writes that VRS rate data to the VRS ratefeedback buffer 320. Then the output merger stage 318 encounters VRSrate data for another tile at the same render target area as thedepth-10 tile, but this new tile has a depth of 7. In response, theoutput merger stage 318 overwrites the shading rate data for thedepth-10 tile in the VRS rate feedback buffer 320 with the shading ratedata for the depth-7 tile.

After the render target frame has been fully rendered, the VRS ratefeedback buffer 320 is considered finished for that frame. Subsequentpost-processing tasks input this buffer and perform post-processingoperations in accordance therewith.

One example of a technique for using the VRS rate feedback buffer 320 isnow provided. In this example, a post-processing task is performed usinga compute shader. The SIMD units 138 operate in two different modes. Ina first mode, a first number of work-items (such as 32) are executed. Ina second mode, a second number of work-items (such as 64) that is twicethe first number are executed. In the second mode, the second number ofwork-items are executed by executing half of the work-items in turns.For example, for a first number of clock cycles, the first half of thework-items are executed and for a second number of clock cycles, thesecond half of the work-items are executed. In this example, a computeshader executes in the second mode and checks the VRS rate feedbackbuffer 320 to determine whether the shading rate is reduced. If theshading rate is reduced, then the shader program terminates the secondhalf of the work-items, which causes the “turn” for the second half ofthe work-items to be skipped, thereby halving the execution time of thecompute shader. Any other technique for reducing execution time of apost-processing task according to the shading rates specified in the VRSrate feedback buffer 320 is possible.

A post processing task is performed by a post-processing unit. Apost-processing unit is any unit capable of performing a particularpost-processing task. Example post-processing units include any portionof the graphics processing pipeline 134, any hardware, software, orcombined hardware/software unit depicted in any of the Figures, or anyother hardware, software or combined hardware/software unit.

FIG. 6 illustrates an example series of operations for generating theVRS rate feedback buffer 320. At state 602, the shading rate data inputto the rasterizer stage 314 is shown. A top-left tile has a 4:1 shadingrate, the top-right and bottom-left tiles have 2:1 shading rates and thebottom-right tile has a 1:1 shading rate. The coarse depth test block315(1) performs the coarse depth test, determining that the bottom-righttile is culled because that tile is occluded by a tile alreadyencountered. The coarse depth test block 315(1) also determines that thebottom-right tile is partially occluded and that the top-right tile andtop-left tile are fully not occluded.

At state 606, the pixel shader stage 316 has modified coverage.Specifically, the pixel shader stage 316 has modified some of thecoverage of the bottom-left tile (for example, by setting one or morefragments to be not covered) and thus the bottom-left tile is indicatedas including a triangle edge. State 608 shows the VRS rate feedback dataas written to the VRS rate feedback buffer 320. The top-left tileincludes the shading rate as indicated in state 602. The top-right andbottom-left tile indicates that there is a triangle edge. Thebottom-right tile includes no data to be written to the VRS ratefeedback buffer 320, because the corresponding tile was culled by thecoarse depth test.

FIG. 7 is a flow diagram of a method 700 for generating data for a VRSrate feedback buffer, according to an example. Although described withrespect to FIGS. 1-6, those of skill in the art will understand that anysystem, configured to perform the steps of method 700 in any technicallyfeasible order, falls within the scope of the present disclosure.

The method 700 begins at step 702, where the graphics processingpipeline 300 performs pixel shading at a shading rate defined by pixelshader variable rate shading (“VRS”) data. At step 704, the graphicsprocessing pipeline 300 updates pixel shader VRS data based on whethertiles are fully or partially covered by a triangle. The pixel shader VRSdata is variable rate shading rates on a per-tile basis that is to beused by the pixel shader stage 316 to determine the pixel shading rateas described elsewhere herein. In some examples, this updating occurs byperforming a coarse depth test. The coarse depth test determines whethertiles are fully occluded, partially occluded, or not occluded bypreviously seen tiles. In addition, in some examples, this updatingoccurs by observing whether the pixel shader stage 316 modifies coveragefor fragments within the tile. If the pixel shader stage 316 modifiescoverage such that a fully not occluded tile has at least one fragmentthat is not covered, then the graphics processing pipeline 300 modifiesupdates the VRS data for that tile to indicate that the tile includes atriangle edge.

At step 706, the graphics processing pipeline 300 writes the VRS ratefeedback buffer 320 based on the updated pixel shader VRS data. In someexamples, the graphics processing pipeline 300 writes a tile of updatedpixel shader VRS data to the VRS rate feedback buffer 320 if the data inthat buffer is occluded by the incoming tile of updated pixel shader VRSdata and does not write the tile if the data in that buffer is notoccluded by the incoming tile of updated pixel shader VRS data.

Each of the units illustrated in the figures represent hardwarecircuitry configured to perform the operations described herein, andcertain units of the graphics processing pipeline 300 are programmableand can thus execute programs.

It should be understood that many variations are possible based on thedisclosure herein. Although features and elements are described above inparticular combinations, each feature or element can be used alonewithout the other features and elements or in various combinations withor without other features and elements.

The methods provided can be implemented in a general purpose computer, aprocessor, or a processor core. Suitable processors include, by way ofexample, a general purpose processor, a special purpose processor, aconventional processor, a digital signal processor (DSP), a plurality ofmicroprocessors, one or more microprocessors in association with a DSPcore, a controller, a microcontroller, Application Specific IntegratedCircuits (ASICs), Field Programmable Gate Arrays (FPGAs) circuits, anyother type of integrated circuit (IC), and/or a state machine. Suchprocessors can be manufactured by configuring a manufacturing processusing the results of processed hardware description language (HDL)instructions and other intermediary data including netlists (suchinstructions capable of being stored on a computer readable media). Theresults of such processing can be maskworks that are then used in asemiconductor manufacturing process to manufacture a processor whichimplements features of the disclosure.

The methods or flow charts provided herein can be implemented in acomputer program, software, or firmware incorporated in a non-transitorycomputer-readable storage medium for execution by a general purposecomputer or a processor. Examples of non-transitory computer-readablestorage mediums include a read only memory (ROM), a random access memory(RAM), a register, cache memory, semiconductor memory devices, magneticmedia such as internal hard disks and removable disks, magneto-opticalmedia, and optical media such as CD-ROM disks, and digital versatiledisks (DVDs).

What is claimed is:
 1. A method for performing shader operations, themethod comprising: performing pixel shading at a shading rate defined bypixel shader variable rate shading (“VRS”) data; and updating the pixelVRS data that indicates one or more shading rates for one or more tilesbased on whether tiles of the one or more tiles include triangle edgesor do not include triangle edges, to generate updated VRS data.
 2. Themethod of claim 1, further comprising: writing to a VRS rate feedbackbuffer based on the updated VRS data, wherein the VRS rate feedbackbuffer includes indications for each tile of the one or more tiles,wherein the indications indicate either a shading rate for a tile basedon the pixel shader variable rate shading data or that the tile includesa triangle edge.
 3. The method of claim 2, further comprising:performing a post-processing task utilizing the VRS rate feedback bufferto reduce a rate at which the post-processing task occurs for at leastone tile.
 4. The method of claim 3, wherein utilizing the VRS ratefeedback buffer to reduce a rate at which the post-processing taskoccurs for at least one tile comprises: if the VRS rate feedback bufferdoes not indicate that the at least one tile includes a triangle edge,then performing the post-processing task at a shading rate referred toin the VRS rate feedback buffer; and if the VRS rate feedback bufferdoes indicate that the at least one tile includes a triangle edge, thenperforming the post-processing task at a shading rate of a rendertarget.
 5. The method of claim 1, wherein updating the pixel shader VRSdata for a tile of the one or more tiles includes: determining that acoarse depth test indicates that the tile is partially covered by atriangle; and in response to the determining, modifying a VRS data forthe tile to indicate that the tile includes a triangle edge.
 6. Themethod of claim 1, wherein updating the pixel shader VRS data for a tileof the one or more tiles includes: determining that a coarse depth testindicates that the tile is fully covered by a triangle; and in responseto the determining, setting, as a shading rate for the tile in updatedVRS data, a shading rate of the tile in the pixel shader variable rateshading data.
 7. The method of claim 1, wherein: the VRS data includesan indication that a tile of the one or more tiles is fully covered; andupdating the pixel shader VRS data for the tile of the one or more tilesincludes: determining that a pixel shader stage has modified coveragefor at least one fragment in the tile to indicate that the at least onefragment is not covered; and in response to the determining, modifyingthe pixel shader VRS data to indicate that the tile includes a triangleedge.
 8. The method of claim 1, wherein: the VRS data includes anindication that a tile of the one or more tiles is fully covered; andupdating the pixel shader VRS data for the tile of the one or more tilesincludes: determining that a pixel shader stage has not modifiedcoverage for any fragment in the tile to indicate that the at least onefragment is not covered; and in response to the determining, setting, asa shading rate for the tile in updated VRS data, a shading rate of thetile in the pixel shader variable rate shading data.
 9. The method ofclaim 2, wherein writing the VRS rate feedback buffer based on theupdated VRS data comprises: writing first updated VRS data for a tilehaving a first depth to the VRS rate feedback buffer; and in response todetermining that second updated VRS data includes data that occludes thefirst updated VRS data, overwriting the first updated VRS data with thesecond updated VRS data in the VRS rate feedback buffer.
 10. A graphicsprocessing pipeline, comprising: pixel shader stage circuitry configuredto perform pixel shading at a shading rate defined by pixel shadervariable rate shading (“VRS”) data; and an output merger stage circuitryconfigured to: update the pixel VRS data that indicates one or moreshading rates for one or more tiles based on whether tiles of the one ormore tiles include triangle edges or do not include triangle edges, togenerate updated VRS data.
 11. The graphics processing pipeline of claim10, wherein: the output merger stage circuitry is further configured towrite to a VRS rate feedback buffer based on the updated VRS data; andthe VRS rate feedback buffer includes indications for each tile of theone or more tiles, wherein the indications indicate either a shadingrate for a tile based on the pixel shader variable rate shading data orthat the tile includes a triangle edge.
 12. The graphics processingpipeline of claim 11, further comprising post-processing circuitryconfigured to: perform a post-processing task utilizing the VRS ratefeedback buffer to reduce a rate at which the post-processing taskoccurs for at least one tile.
 13. The graphics processing pipeline ofclaim 12, wherein utilizing the VRS rate feedback buffer to reduce arate at which the post-processing task occurs for at least one tilecomprises: if the VRS rate feedback buffer does not indicate that the atleast one tile includes a triangle edge, then performing thepost-processing task at a shading rate referred to in the VRS ratefeedback buffer; and if the VRS rate feedback buffer does indicate thatthe at least one tile includes a triangle edge, then performing thepost-processing task at a shading rate of a render target.
 14. Thegraphics processing pipeline of claim 10, wherein updating the pixelshader VRS data for a tile of the one or more tiles includes:determining that a coarse depth test indicates that the tile ispartially covered by a triangle; and in response to the determining,modifying a VRS data for the tile to indicate that the tile includes atriangle edge.
 15. The graphics processing pipeline of claim 10, whereinupdating the pixel shader VRS data for a tile of the one or more tilesincludes: determining that a coarse depth test indicates that the tileis fully covered by a triangle; and in response to the determining,setting, as a shading rate for the tile in updated VRS data, a shadingrate of the tile in the pixel shader variable rate shading data.
 16. Thegraphics processing pipeline of claim 10, wherein: the VRS data includesan indication that a tile of the one or more tiles is fully covered; andupdating the pixel shader VRS data for the tile of the one or more tilesincludes: determining that a pixel shader stage has modified coveragefor at least one fragment in the tile to indicate that the at least onefragment is not covered; and in response to the determining, modifyingthe pixel shader VRS data to indicate that the tile includes a triangleedge.
 17. The graphics processing pipeline of claim 10, wherein: the VRSdata includes an indication that a tile of the one or more tiles isfully covered; and updating the pixel shader VRS data for the tile ofthe one or more tiles includes: determining that a pixel shader stagehas not modified coverage for any fragment in the tile to indicate thatthe at least one fragment is not covered; and in response to thedetermining, setting, as a shading rate for the tile in updated VRSdata, a shading rate of the tile in the pixel shader variable rateshading data.
 18. The graphics processing pipeline of claim 11, whereinwriting the VRS rate feedback buffer based on the updated VRS datacomprises: writing first updated VRS data for a tile having a firstdepth to the VRS rate feedback buffer; and in response to determiningthat second updated VRS data includes data that occludes the firstupdated VRS data, overwriting the first updated VRS data with the secondupdated VRS data in the VRS rate feedback buffer.
 19. A non-transitorycomputer-readable medium storing instructions that, when executed by aprocessor, cause the processor to perform shader operations, the shadingoperations comprising: performing pixel shading at a shading ratedefined by pixel shader variable rate shading (“VRS”) data; and updatingthe pixel VRS data that indicates one or more shading rates for one ormore tiles based on whether tiles of the one or more tiles includetriangle edges or do not include triangle edges, to generate updated VRSdata.
 20. The non-transitory computer-readable medium of claim 19,wherein the shading operations further comprise: writing to a VRS ratefeedback buffer based on the updated VRS data, wherein the VRS ratefeedback buffer includes indications for each tile of the one or moretiles, wherein the indications indicate either a shading rate for a tilebased on the pixel shader variable rate shading data or that the tileincludes a triangle edge.